import Template from '../template'

export default {
  /**
	 * 默认参数
	 */
  setDefaults() {
    return {
      date: +(new Date) + 60 * 1000 * 1,
      refresh: 1000,
      offset: 0,
      onEnd() { },
      render(date) { },
    }
  },

  /**
	 * 倒计时模板
	 * @param {Object} date 日期
	 * @param {String} refresh 刷新间隔时间
	 * @param {Boolean} offset 相差的时间
	 * @param {Function} onEnd() 倒计时结束回调函数
	 * @param {Function} render() 渲染回调函数
	 */

  init(opts = {}) {
    const options = Object.assign({}, this.setDefaults(), opts)

    // 实例化组件
    const template = new Template({
      scope: `$xcx.countdown`,
      data: options,
      methods: {
        /**
         * 计算日期差
         */
        getDiffDate() {
          let diff = (options.date - Date.now() + options.offset) / 1000
          let dateData = {
            years: 0,
            days: 0,
            hours: 0,
            min: 0,
            sec: 0,
            millisec: 0,
          }

          if (diff <= 0) {
            if (this.interval) {
              this.stop()
              options.onEnd()
            }
            return dateData
          }

          if (diff >= (365.25 * 86400)) {
            dateData.years = Math.floor(diff / (365.25 * 86400))
            diff -= dateData.years * 365.25 * 86400
          }

          if (diff >= 86400) {
            dateData.days = Math.floor(diff / 86400)
            diff -= dateData.days * 86400
          }

          if (diff >= 3600) {
            dateData.hours = Math.floor(diff / 3600)
            diff -= dateData.hours * 3600
          }

          if (diff >= 60) {
            dateData.min = Math.floor(diff / 60)
            diff -= dateData.min * 60
          }

          dateData.sec = Math.round(diff)

          dateData.millisec = diff % 1 * 1000

          return dateData
        },

        /**
         * 补零
         */
        leadingZeros(num, length = 2) {
          num = String(num)
          if (num.length > length) return num
          return (Array(length + 1).join(`0`) + num).substr(-length)
        },

        /**
         * 更新倒计时
         */
        update(newDate) {
          options.date = typeof newDate !== `object` ? new Date(newDate) : newDate
          this.render()
          return this
        },

        /**
         * 停止倒计时
         */
        stop() {
          if (this.interval) {
            clearInterval(this.interval)
            this.interval = !1
          }
          return this
        },

        /**
         * 渲染组件
         */
        render() {
          options.render(this.getDiffDate())
          return this
        },

        /**
         * 启动倒计时
         */
        start() {
          if (this.interval) return !1
          this.render()
          if (options.refresh) {
            this.interval = setInterval(() => {
              this.render()
            }, options.refresh)
          }
          return this
        },

        /**
         * 更新offset
         */
        updateOffset(offset) {
          options.offset = offset
          return this
        },

        /**
         * 重启倒计时
         */
        restart(opts = {}) {
          this.interval = !1
          this.start()
          return this
        }
      },
    })

    template.restart(options)

    return template
  }
}